﻿/*
    Questa classe funge da proxy locale per le interrogazioni al server di loa
    e al server di google. Mette a disposizione due metodi: performRequest, che 
    esegue un XmlHttpRequest al server di loa verso un certo webservice, e 
    performGoogleRequest, che invece effettua richieste al server di google per 
    ottenere GDirections.
*/
MapControl2.AAANetUtils = function()
{
    this._requestStatus = 0;    // stato della richiesta (i vari stati sono elencati al termine del file)
    this._requestResult = null; // risultato della richiesta
    this._counter = 0;
};

MapControl2.AAANetUtils.prototype = {

    // ------------------ public functions ----------------------------------------------------
    /*
        Effettua una chiamata ad un webservice sul server di loa. I parametri sono:
        - type = tipo della richiesta (tra quelli registrati)
        - params = array che contiene i parametri della richiesta
        - ok_callback = funzione di callback richiamata se tutto va a buon fine, passando
            il risultato della richiesta
        - dontJoinArray = se il ws riceve come unico parametro un array e dontJoinArray
            è settato a true, indica di non considerare il parametro <params> 
            come un array di parametri ma come un solo parametro array
    */
    performRequest: function(type, params, ok_callback, err_callback, dontJoinArray)
    {
        // ricava la stringa della richiesta in funzione del parametro <type>...
        var _req = MapControl2.AAANetUtils._requests[type];
        var _params = null;
        
        // ...costruisce la stringa dei parametri in funzione del parametro <params>
        // applicando le convenzioni descritte in precedenza...
        if (params !== null)
        {
            if (dontJoinArray && dontJoinArray == true)
            {
                _params = 'params';
            }else{
                if (params.constructor.toString().indexOf("Array") == -1)
                {
                    // only one parameter
                    _params = params;
                }else 
                {
                    // more than one parameter
                    _params = params.join(', ');
                }
            }
            _params += ', ';
        }else 
        {
            // no parameters
            _params = "";
        }
        
        // ...completa la richiesta...
        _req = _req.replace("<params>", _params);
        
        // ...e la effettua.
        eval(_req);
    },
    
    // richiede un percorso a google che passa per i punti indicati.
    // _gDir è un riferimento a un oggetto GDirections che conterrà il 
    // risultato dell'interrogazione (sovrascrive la precedente GDirections).
    // points è un array di GLatLng corrispondente ai punti per i quali
    // deve passare il percorso. ok_callback è una funzione di callback cui 
    // verrà passato, in caso di esito positivo, il risultato dell'interrogazione
    // a google, ovvero un oggetto google.maps.Directions
    performGoogleRequest: function(_gDir, points, ok_callback, error_callback)
    {    
        _gDir.clear();
        // definisce gli handler agli eventi load ed error di _gDir...
        var loadHandler = google.maps.Event.addListener(_gDir, "load", _onRouteLoad);
        var errHandler = google.maps.Event.addListener(_gDir, "error", _onError);
        
        // ...e avvia l'interrogazione.
        try
        {
            _gDir.loadFromWaypoints(points, {getPolyline: true, getSteps:true});
        }catch(e)
        {
            alert(e.message);
        }
        
        function _onRouteLoad()
        {
            // se la richiesta è andata a buon fine si rimuovono gli handler
            // precedentemente definiti e si richiama la funzione di callback
            google.maps.Event.removeListener(loadHandler);
            google.maps.Event.removeListener(errHandler);
            ok_callback();
        };
        
        function _onError()
        {
            var errStr = "Error computing directions ("+this.getStatus().code+")\n";
	        switch(this.getStatus().code)
	        {
	            case G_GEO_UNKNOWN_ADDRESS:
	                errStr += "Unknown address";
	                break;
	            case G_GEO_SERVER_ERROR:
	                errStr += "Server error";
	                break;
	            case G_GEO_MISSING_QUERY:
	                errStr += "Incorrect query";
	                break;
	            case G_GEO_BAD_KEY:
	                errStr += "Google Key not valid";
	                break;
                case G_GEO_BAD_REQUEST:
	                errStr += "Bad request";
	                break;
	            case G_GEO_UNKNOWN_DIRECTIONS:
	                errStr += "Unknown directions";
	                break;
	            default:
	                errStr += "Unknown error";
	        }
	        errStr += "\n"+this.getStatus().request;
	        if (error_callback)
	            error_callback(errStr);            
        };
    },
    
    _performReverseGeocoding: function(latlng, ok_callback, err_callback)
    {
        var lat = latlng.lat().toString();
        var lng = latlng.lng().toString();
        var paramArray = new Array(lat, lng);
        this.performRequest(MapControl2.AAANetUtils.REVERSE_GEOCODING_REQUEST, paramArray, ok_callback)
    },
    
    performReverseGeocoding: function (latlng, ok_callback, err_calback)
    {   
        var tempL = latlng.lat().toString();
	    var tempL2 = latlng.lng().toString();
	    
        var url = "http://"+window.location.host+"/service/rest/RestGeoRef.ashx?method=reverseGeoCoding&lat="+tempL+"&lng=" + tempL2 + "&format=json";
	    var req = new XMLHttpRequest(), err = null;
	    req.onreadystatechange = function () { if (req.readyState == 4)
            if(req.status == 200)
            {
                var tmp = eval('(' + req.responseText + ')'); 
                // var tmp2 = tmp.split('address:')[1];
                var risultato = 'new address';
                if(tmp.Status != "fail")
                    risultato = tmp.Payload[0];
                /*
                else
                    if (!document.all) { 
                        err = "Reverse Geocoding web service fails.\nError: " + tmp.Message;
                        if (err_calback) err_calback(err);
                    }
                */
                ok_callback(risultato);
            }
            else{
                err = "Reverse Geocoding\nError reading from webservices: "+req.status;
                if (err_calback) err_calback(err);
            } };
        req.open("GET", url, true);
        req.send(null);
    },
    
    // --------------------------------------------------------------------------------

    // --------------- properties -----------------------------------------------------
    getRequestStatus: function()
    {
        return (this._requestStatus);
    },
    
    getRequestResult: function()
    {
        return (this._requestResult);
    },
    // -------------------------------------------------------------------------------
    
    
    // --------------- webservices callbacks -----------------------------------------
    // callbacks per le interrogazioni al server di loa.
    _onRequestSuccess: function(result, cback_arr, methodName)
    {
        // in caso di successo si invoca la funzione di callback passando il risultato
        this._requestResult = result;
        this._requestStatus = 0;
        cback_arr[0](result);
    },
    
    _onRequestFailure: function(error, cback_arr, methodName)
    {
        // altrimenti si gestiscono gli eventuali errori (per ora si stampano)
        this._requestResult = error;
        this._requestStatus = 1;
        cback_arr[1](error);
    }
    // -------------------------------------------------------------------------------
};

// tipi di richieste possibili al server di loa
MapControl2.AAANetUtils.GEOTRIP_REQUEST_BY_ID = 0;
MapControl2.AAANetUtils.MULTIPLE_GEOCODING_REQUEST = 1;
MapControl2.AAANetUtils.GEOCODING_REQUEST = 2;

// stringhe di richiesta associate ai vari tipi di richiesta.
// notare il placemark <params> in corrispondenza dei parametri della richiesta.
MapControl2.AAANetUtils._requests = new Array(
    "TripLOA.WebService.georef_test_2.WSGeoRef.getTripByID(<params> this._onRequestSuccess, this._onRequestFailure, [ok_callback, err_callback])",
    "TripLOA.WebService.georef_test_2.WSGeoRef.multipleGeoCoding(<params> this._onRequestSuccess, this._onRequestFailure, [ok_callback, err_callback])",
    "TripLOA.WebService.georef_test_2.WSGeoRef.geoCoding(<params> this._onRequestSuccess, this._onRequestFailure, [ok_callback, err_callback])"
);

// registrazione classe
MapControl2.AAANetUtils.registerClass('MapControl2.AAANetUtils');

if (typeof(Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();